
# import libraries for data manipulation
import pandas as pd

# import libraries for data visualization
%matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns

# misc/other imports
import warnings

# import libraries for python utils
import tabulate


# GLOBAL OPTIONS ---

# To avoid clutter in the output, suppress warnings
warnings.filterwarnings("ignore")

# Set global figure size for all plots
plt.rcParams["figure.figsize"] = (15, 6)
plt.rcParams["font.size"] = 12

# Set the grid style globally (for both major and minor grids)
# plt.rcParams['axes.grid'] = True
plt.rcParams["grid.linestyle"] = "--"
plt.rcParams["grid.alpha"] = 0.6

plt.rcParams["grid.color"] = "#E2E0E0FF"

# Set global font sizes for title, xlabel, and ylabel
plt.rcParams["axes.titlesize"] = 16  # Default font size for plot titles
plt.rcParams["axes.labelsize"] = 12  # Default font size for x and y labels

# Seaborne style ---

# Set global Seaborn style and context
# ref: https://r02b.github.io/seaborn_palettes/
sns.set_theme(style="whitegrid", palette="muted", context="notebook")


# UTILS (plot) ---


def set_fig_size(width, height):
    """
    Set figure size (for upcoming plot only)
    NOTE: this will apply to next plot only (& not all plot)
    """
    plt.figure(figsize=(width, height))


def set_small_fig():
    """
    (5, 5) -> ar: 1
    Square shaped fig (eg: scatter plot)
    """
    set_fig_size(5, 5)


def set_medium_fig():
    """
    (9, 6) -> ar: 1.5
    Normal | Medium
    """
    # alternate = (12, 8)
    set_fig_size(9, 6)


def set_large_fig():
    """
    (12, 6) -> ar: 2
    Large figure
    """
    set_fig_size(12, 6)


def set_vlarge_fig():
    """
    (13, 5) -> ar: 2.5
    Very Large figure (Eg Time Series covering long span)
    """
    set_fig_size(15, 6)


# UTILS (PANDAS) ---


def tableit(series: pd.Series, index_label: str = None, value_label: str = "value"):
    """
    Display a pandas Series as a formatted table using the tabulate library.
    Args:
        series (pd.Series): The pandas Series to be displayed.
        index_name (str): The name of the index column. Default to `series.name`
    Returns:
        None
    """
    i_name = index_label if index_label else series.name
    table = tabulate.tabulate(
        series.items(), headers=[i_name, value_label], tablefmt="grid"
    )
    print(table)


# todo: decide default value for show_index
def tableit_df(df: pd.DataFrame, show_index: bool = True):
    """
    Display a pandas DataFrame as a formatted table using the tabulate library.
    Args:
        df (pd.DataFrame): The pandas DataFrame to be displayed.
        show_index (bool): Whether to display the DataFrame index. Default is True.
    Returns:
        None
    """
    # Convert DataFrame to a tabulated string
    table = tabulate.tabulate(
        df, headers="keys", tablefmt="pretty", showindex=show_index
    )
    print(table)


# UTILS (Python | Primitive) ---


def snake_to_pascal(snake_str, join_with=" "):
    """Convert snake_case to PascalCase (eg my_name -> MyName)
    Args:
        snake_str (str): string to convert
        join_with (str): character to join the components, default is space
    """
    components = snake_str.split("_")
    return join_with.join(x.title() for x in components)


def format_pct(val):
    """Format a val as percentage i.e max 2 decimal value & adding % at the end"""
    return f"{val:.2f}%"


# UTILS (Python | Stats) ---


def calc_iqr(series: pd.Series):
    """
    series: array of numerical values
    """
    Q1 = series.quantile(0.25)
    Q3 = series.quantile(0.75)
    IQR = Q3 - Q1
    return Q1, Q3, IQR


def to_percentage(value):
    """value is expected to be a normalized float value in [0, 1]"""
    return format_pct(value * 100)


# uncomment and run the following lines for Google Colab
# from google.colab import drive
# drive.mount('/content/drive')


# Load the dataset
df = pd.read_csv('foodhub_order.csv')
# Make a copy of the original DataFrame (to have a original copy of the data)
original_df = df.copy()


# View the first 5 rows
df.head(5)


rows, cols = df.shape
rows, cols

(1898, 9)


tableit(df.dtypes, index_label='column')

+-----------------------+---------+
| column                | value   |
+=======================+=========+
| order_id              | int64   |
+-----------------------+---------+
| customer_id           | int64   |
+-----------------------+---------+
| restaurant_name       | object  |
+-----------------------+---------+
| cuisine_type          | object  |
+-----------------------+---------+
| cost_of_the_order     | float64 |
+-----------------------+---------+
| day_of_the_week       | object  |
+-----------------------+---------+
| rating                | object  |
+-----------------------+---------+
| food_preparation_time | int64   |
+-----------------------+---------+
| delivery_time         | int64   |
+-----------------------+---------+


# ? As suggested in question, so using the `info()` as well
df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1898 entries, 0 to 1897
Data columns (total 9 columns):
 #   Column                 Non-Null Count  Dtype  
---  ------                 --------------  -----  
 0   order_id               1898 non-null   int64  
 1   customer_id            1898 non-null   int64  
 2   restaurant_name        1898 non-null   object 
 3   cuisine_type           1898 non-null   object 
 4   cost_of_the_order      1898 non-null   float64
 5   day_of_the_week        1898 non-null   object 
 6   rating                 1898 non-null   object 
 7   food_preparation_time  1898 non-null   int64  
 8   delivery_time          1898 non-null   int64  
dtypes: float64(1), int64(4), object(4)
memory usage: 133.6+ KB


has_missing_values =  df.isnull().any().any()
has_missing_values

False


stat_summary  = df.describe(include='all').T
stat_summary


# statistical summary for the 'food_preparation_time' column
food_preparation_summary = df['food_preparation_time'].describe()
food_preparation_summary

count    1898.000000
mean       27.371970
std         4.632481
min        20.000000
25%        23.000000
50%        27.000000
75%        31.000000
max        35.000000
Name: food_preparation_time, dtype: float64


df['rating'].value_counts()

Not given    736
5            588
4            386
3            188
Name: rating, dtype: int64


# GENERIC WAY :- An alternate way to find missing values
# NOTE: this will be helpful especially when there are more than 1 rating values which are not a number
#       (ie for eg 'Not Given', 'Not rated', 'NA', etc)
#       In present case, there is only 1 value 'Not rated',
#       so it was straight forward to determine just via seeing stats-info from `value_counts()`

# find non-numeric values in the 'rating' column by converting the column to numeric & checking for NaN values
non_numeric_ratings_count = pd.to_numeric(df['rating'], errors='coerce').isnull().sum()
print(f"Number of non-numeric values in the 'rating' column: {non_numeric_ratings_count}")

Number of non-numeric values in the 'rating' column: 736


# ! NOTE: only attribute which are used further in some sort of computation/manipulation, is addressed here !!

# 1.
# NOTE: the modification is done inplace, as original df backup us already there i.e `original_df`
# convert the 'rating' column to a numeric type and replace 'Not given' with NaN for consistency.
df['rating'] = pd.to_numeric(df['rating'], errors='coerce')


# Verify the changes
df['rating'].dtype

dtype('float64')


distinct_ratings = df['rating'].nunique()
distinct_ratings

3


df['rating'].value_counts()

5.0    588
4.0    386
3.0    188
Name: rating, dtype: int64


# get non-numeric values count in the new 'rating' column
new_val = df['rating'].isnull().sum()
prev_val = non_numeric_ratings_count
print(f"For verification (non-numeric count): {new_val} (previously {prev_val}), is_same = {new_val == prev_val}")

For verification (non-numeric count): 736 (previously 736), is_same = True


df['rating'].info()

<class 'pandas.core.series.Series'>
RangeIndex: 1898 entries, 0 to 1897
Series name: rating
Non-Null Count  Dtype  
--------------  -----  
1162 non-null   float64
dtypes: float64(1)
memory usage: 15.0 KB


# !! Assumption : Before this computation, ratings column should be converted to numeric type (ie Imputed with NaN for 'Not given' values)
# Check:-
# Top 5 restaurants with the highest average rating
top_5_restaurant_with_highest_ratings = df.groupby('restaurant_name')['rating'].mean().nlargest(5)
tableit(top_5_restaurant_with_highest_ratings, index_label='Restaurant', value_label='Average Rating')

+--------------------+------------------+
| Restaurant         |   Average Rating |
+====================+==================+
| 'wichcraft         |                5 |
+--------------------+------------------+
| 67 Burger          |                5 |
+--------------------+------------------+
| Anjappar Chettinad |                5 |
+--------------------+------------------+
| Asuka Sushi        |                5 |
+--------------------+------------------+
| Balade             |                5 |
+--------------------+------------------+


class UnivariatePlotHelper:
    def __init__(self, df: pd.DataFrame):
        self.df = df

    def draw_countplot(
        self,
        attribute: str,
        *,
        label=None,
        rot=0,
        order=None,
        sort=True,
        palette=None,
        showgrid=None,
    ):
        """
        sort: will be used only if order is None
        """
        # prep (meta) --
        xlabel = label if label else snake_to_pascal(attribute)
        priority = None
        if order is not None:
            priority = order
        elif sort:
            # sort by count
            # NOTE: value_counts() returns a Series sorted by values (in DESC order by default)
            priority = df[attribute].value_counts().index

        # plot (crux) --
        ax = sns.countplot(data=df, x=attribute, order=priority, palette=palette)
        # display count above each bar
        ax.bar_label(ax.containers[0])

        # aesthetics --
        plt.title(f"Bar Graph of {xlabel}")
        plt.xlabel(xlabel)
        plt.ylabel("count")
        plt.xticks(rotation=rot)
        if showgrid:
            plt.grid(True)
        plt.show()

    def draw_boxplot(self, attribute: str, *, label=None):
        """
        attribute: name of the column
        """
        # prep
        xlabel = label if label else snake_to_pascal(attribute)
        # plot
        sns.boxplot(data=df, x=attribute)
        # aesthetics
        plt.title(f"Box Plot of {xlabel}")
        plt.xlabel(xlabel)
        plt.show()

    def draw_boxplot_fromseries(self, series: pd.Series, *, label=None):
        """
        series: array of numeric values
        """
        # prep
        xlabel = label if label else snake_to_pascal(series.name)
        # plot
        sns.boxplot(x=series)
        # aesthetics
        plt.title(f"Box Plot of {xlabel}")
        plt.xlabel(xlabel)
        plt.show()

    def draw_histplot(self, attribute: str, *, bins="auto", label=None, color=None):
        # prep
        xlabel = label if label else snake_to_pascal(attribute)
        # plot
        sns.histplot(data=df, x=attribute, bins=bins, kde=True, color=color)
        # aesthetics
        plt.title(f"Histogram of {xlabel}")
        plt.xlabel(xlabel)
        plt.ylabel("frequeuncy")
        plt.show()

    def draw_pieplot(self, attribute: str, *, label=None):
        # prep
        label = label if label else snake_to_pascal(attribute)
        # plot
        counts = df[attribute].value_counts()
        # aesthetics
        plt.title(f"Pie Chart of {label}", pad=20)
        plt.pie(counts, labels=counts.index, autopct="%1.1f%%", startangle=140)
        plt.axis("equal")
        plt.show()


# helpers (init | singleton)

plot_helper = UnivariatePlotHelper(df)


df.columns.to_list()

['order_id',
 'customer_id',
 'restaurant_name',
 'cuisine_type',
 'cost_of_the_order',
 'day_of_the_week',
 'rating',
 'food_preparation_time',
 'delivery_time']


# total orders
total_orders = df.shape[0]
total_customers = df['customer_id'].nunique()
print(f'Total Orders: {total_orders} & Total Customers: {total_customers}')

Total Orders: 1898 & Total Customers: 1200


# Descriptive stats
restaurant_order_counts = df['restaurant_name'].value_counts()
restaurant_order_counts

Shake Shack                  219
The Meatball Shop            132
Blue Ribbon Sushi            119
Blue Ribbon Fried Chicken     96
Parm                          68
                            ... 
Sushi Choshi                   1
Dos Caminos Soho               1
La Follia                      1
Philippe Chow                  1
'wichcraft                     1
Name: restaurant_name, Length: 178, dtype: int64


# PLOT

# as there are too many categories, so setting bit unconventional figuresize
set_fig_size(80, 20)
# restaurant names -> nominal variable | categorical
plot_helper.draw_countplot('restaurant_name', rot=90)


top_n = 10
# Top 10 restaurants with the highest demand (ie maximum orders)
top_restaurants_order_count = df['restaurant_name'].value_counts().nlargest(top_n)


top_restaurants_names = top_restaurants_order_count.index.to_list()
print(f'Top {top_n} restaurants with the highest demand (ie maximum orders):')
print(top_restaurants_names)

Top 10 restaurants with the highest demand (ie maximum orders):
['Shake Shack', 'The Meatball Shop', 'Blue Ribbon Sushi', 'Blue Ribbon Fried Chicken', 'Parm', 'RedFarm Broadway', 'RedFarm Hudson', 'TAO', 'Han Dynasty', 'Blue Ribbon Sushi Bar & Grill']


tableit(top_restaurants_order_count, value_label='#orders')

+-------------------------------+-----------+
| restaurant_name               |   #orders |
+===============================+===========+
| Shake Shack                   |       219 |
+-------------------------------+-----------+
| The Meatball Shop             |       132 |
+-------------------------------+-----------+
| Blue Ribbon Sushi             |       119 |
+-------------------------------+-----------+
| Blue Ribbon Fried Chicken     |        96 |
+-------------------------------+-----------+
| Parm                          |        68 |
+-------------------------------+-----------+
| RedFarm Broadway              |        59 |
+-------------------------------+-----------+
| RedFarm Hudson                |        55 |
+-------------------------------+-----------+
| TAO                           |        49 |
+-------------------------------+-----------+
| Han Dynasty                   |        46 |
+-------------------------------+-----------+
| Blue Ribbon Sushi Bar & Grill |        44 |
+-------------------------------+-----------+


plot_helper.draw_countplot('restaurant_name', label=f'Top {top_n} Restaurants', rot=30, order=top_restaurants_names)


# less demanding restaurants order counts
least_n = 10
bottom_restaurants_order_count = df['restaurant_name'].value_counts().nsmallest(least_n)


bottom_restaurants_names = bottom_restaurants_order_count.index.to_list()
print(f'The {least_n} restaurants with the least demand (ie fewest orders):')
print(bottom_restaurants_names)

The 10 restaurants with the least demand (ie fewest orders):
['Le Zie 2000 Trattoria', 'Cafe de La Esquina', "Sarabeth's West", 'Frank Restaurant', "Hiroko's Place", 'Rye House', 'Lamarca Pasta', '67 Burger', 'Lucky Strike', "Paul & Jimmy's"]


plot_helper.draw_countplot('restaurant_name', label=f'Bottom {least_n} Restaurants', rot=30, order=bottom_restaurants_names)


# Descriptive stats
restaurant_order_counts.describe()

count    178.000000
mean      10.662921
std       24.047008
min        1.000000
25%        1.000000
50%        3.000000
75%        8.750000
max      219.000000
Name: restaurant_name, dtype: float64


# PLOT

plot_helper.draw_boxplot_fromseries(restaurant_order_counts)


# STATS

q1, q3, _ = calc_iqr(restaurant_order_counts)
q1, q3

(1.0, 8.75)


# Explore | Stats

# restaurants with more than 10
restaurant_names_with_more_than_10_orders = restaurant_order_counts[restaurant_order_counts > 10].index

# get total orders count from all such restaurants
filtered_df = df[df['restaurant_name'].isin(restaurant_names_with_more_than_10_orders)]

filtered_df.shape

(1494, 9)


df.shape

(1898, 9)


diff = df.shape[0] - filtered_df.shape[0]
diff_pct = diff / df.shape[0] * 100
print(f"Total orders from restaurants with more than 10 orders: {diff} (ie {format_pct(diff_pct)}%)")

Total orders from restaurants with more than 10 orders: 404 (ie 21.29%%)


# categorical
x = 'cuisine_type'
plot_helper.draw_countplot(x, rot=45)


# helper cell
# : to find next column name
df.columns

Index(['order_id', 'customer_id', 'restaurant_name', 'cuisine_type',
       'cost_of_the_order', 'day_of_the_week', 'rating',
       'food_preparation_time', 'delivery_time'],
      dtype='object')


x = 'cost_of_the_order'


df[x].describe()

count    1898.000000
mean       16.498851
std         7.483812
min         4.470000
25%        12.080000
50%        14.140000
75%        22.297500
max        35.410000
Name: cost_of_the_order, dtype: float64


# Plot

plot_helper.draw_histplot(x)


# Descriptive stats

q1, q3, iqr = calc_iqr(df[x])
q1, q3, iqr

(12.08, 22.2975, 10.2175)


# Plot

plot_helper.draw_boxplot(x)


# Stats | More

# deeper insights
print(f"skewness: {df['cost_of_the_order'].skew()}")
print(f"kurtosis: {df['cost_of_the_order'].kurt()}")

skewness: 0.6217469995871637
kurtosis: -0.6078508734318953


# helper cell
df.columns

Index(['order_id', 'customer_id', 'restaurant_name', 'cuisine_type',
       'cost_of_the_order', 'day_of_the_week', 'rating',
       'food_preparation_time', 'delivery_time'],
      dtype='object')


# categorical
x = 'day_of_the_week'


plot_helper.draw_countplot(x)


# Descriptive Statistics
order_count_by_day_category = df['day_of_the_week'].value_counts()
order_count_by_day_category_pct = df['day_of_the_week'].value_counts(normalize=True) * 100

print('Order Counts by Day of the Week:', order_count_by_day_category, sep='\n')
print('\nPercentage of Orders by Day of the Week:', order_count_by_day_category_pct, sep='\n')

Order Counts by Day of the Week:
Weekend    1351
Weekday     547
Name: day_of_the_week, dtype: int64

Percentage of Orders by Day of the Week:
Weekend    71.18019
Weekday    28.81981
Name: day_of_the_week, dtype: float64


plot_helper.draw_pieplot(x)


# helper cell
df.columns

Index(['order_id', 'customer_id', 'restaurant_name', 'cuisine_type',
       'cost_of_the_order', 'day_of_the_week', 'rating',
       'food_preparation_time', 'delivery_time'],
      dtype='object')


# Categorical | Ordinal
x = 'rating'
df[x].dtype

dtype('float64')


# Note; here null is same as "Not given" as we have already converted "Not given" to NaN
ratings_not_given = df[x].isnull().sum()
ratings_not_given

736


ratings_not_given_pct = ratings_not_given / total_orders * 100
print(f"Percentage of orders wihtout rating: {format_pct(ratings_not_given_pct)}")

Percentage of orders wihtout rating: 38.78%


# Plot
plot_helper.draw_pieplot(x)


# Stats

tableit(df[x].value_counts(), index_label='Rating', value_label='#Orders')

+----------+-----------+
|   Rating |   #Orders |
+==========+===========+
|        5 |       588 |
+----------+-----------+
|        4 |       386 |
+----------+-----------+
|        3 |       188 |
+----------+-----------+


plot_helper.draw_countplot(x)


# helper cells
df.columns

Index(['order_id', 'customer_id', 'restaurant_name', 'cuisine_type',
       'cost_of_the_order', 'day_of_the_week', 'rating',
       'food_preparation_time', 'delivery_time'],
      dtype='object')


x = 'food_preparation_time'


# Stats
df[x].describe()

count    1898.000000
mean       27.371970
std         4.632481
min        20.000000
25%        23.000000
50%        27.000000
75%        31.000000
max        35.000000
Name: food_preparation_time, dtype: float64


df[x].nunique()

16


# explore | stats

food_preparation_time_counts = df[x].value_counts()
food_preparation_time_counts_pct = df[x].value_counts(normalize=True) * 100

food_preparation_time_counts

21    135
23    123
27    123
22    123
28    121
24    121
20    119
30    119
33    118
35    117
31    116
26    115
25    113
34    113
32    113
29    109
Name: food_preparation_time, dtype: int64


food_preparation_time_counts_pct

21    7.112750
23    6.480506
27    6.480506
22    6.480506
28    6.375132
24    6.375132
20    6.269758
30    6.269758
33    6.217071
35    6.164384
31    6.111697
26    6.059009
25    5.953635
34    5.953635
32    5.953635
29    5.742887
Name: food_preparation_time, dtype: float64


plot_helper.draw_histplot(x)


plot_helper.draw_countplot(x, sort=False)


plot_helper.draw_pieplot(x)


plot_helper.draw_boxplot(x)


df.columns

Index(['order_id', 'customer_id', 'restaurant_name', 'cuisine_type',
       'cost_of_the_order', 'day_of_the_week', 'rating',
       'food_preparation_time', 'delivery_time'],
      dtype='object')


# numeric
x = 'delivery_time'


df[x].describe()

count    1898.000000
mean       24.161749
std         4.972637
min        15.000000
25%        20.000000
50%        25.000000
75%        28.000000
max        33.000000
Name: delivery_time, dtype: float64


plot_helper.draw_histplot(x)


# Stats

# frequency of each delivery time
delivery_time_counts = df[x].value_counts()
delivery_time_counts

24    162
28    148
29    148
26    141
27    138
30    133
25    120
19     90
16     90
20     88
15     87
22     85
18     83
21     81
17     78
23     77
32     59
33     49
31     41
Name: delivery_time, dtype: int64


plot_helper.draw_countplot(x, sort=False)


plot_helper.draw_boxplot(x)


df[x].describe()

count    1898.000000
mean       24.161749
std         4.972637
min        15.000000
25%        20.000000
50%        25.000000
75%        28.000000
max        33.000000
Name: delivery_time, dtype: float64


# Q7.
k = 5
# NOTE: The resulting object will be in descending order so that the first element is the most frequently-occurring element.
top_5_restaurant = df['restaurant_name'].value_counts().head(5)
top_5_restaurant

Shake Shack                  219
The Meatball Shop            132
Blue Ribbon Sushi            119
Blue Ribbon Fried Chicken     96
Parm                          68
Name: restaurant_name, dtype: int64


tableit(top_5_restaurant, index_label='Restaurant', value_label='Order Count')

+---------------------------+---------------+
| Restaurant                |   Order Count |
+===========================+===============+
| Shake Shack               |           219 |
+---------------------------+---------------+
| The Meatball Shop         |           132 |
+---------------------------+---------------+
| Blue Ribbon Sushi         |           119 |
+---------------------------+---------------+
| Blue Ribbon Fried Chicken |            96 |
+---------------------------+---------------+
| Parm                      |            68 |
+---------------------------+---------------+


weekend_orders = df[df['day_of_the_week'] == 'Weekend']
cuisine_order_count = weekend_orders['cuisine_type'].value_counts()
cuisine_order_count

American          415
Japanese          335
Italian           207
Chinese           163
Mexican            53
Indian             49
Mediterranean      32
Middle Eastern     32
Thai               15
French             13
Korean             11
Southern           11
Spanish            11
Vietnamese          4
Name: cuisine_type, dtype: int64


# most popular cuisine and its percentage
most_popular_cuisine = cuisine_order_count.idxmax()
percentage = (cuisine_order_count.max() / cuisine_order_count.sum()) * 100

print(f"The most popular cuisine on weekends is {most_popular_cuisine} with {format_pct(percentage)} of weekend orders.")

The most popular cuisine on weekends is American with 30.72% of weekend orders.


# mask for orders with cost greater than 20
mask_cost_above_20 = df['cost_of_the_order'] > 20
percent_of_order_above_20 = mask_cost_above_20.mean() * 100
print(f"Percentage of orders with a cost above 20 dollar is {format_pct(percent_of_order_above_20)}")

Percentage of orders with a cost above 20 dollar is 29.24%


df['cost_of_the_order'].describe()

count    1898.000000
mean       16.498851
std         7.483812
min         4.470000
25%        12.080000
50%        14.140000
75%        22.297500
max        35.410000
Name: cost_of_the_order, dtype: float64


avg_delivery_time = df['delivery_time'].mean()
print(f"The average delivery time is {avg_delivery_time:.2f} minutes.")

The average delivery time is 24.16 minutes.


# Count the number of orders for each customer
order_counts = df['customer_id'].value_counts()

# Get the top 3 customers
top_3_customers = order_counts.head(3)

top_3_customers

52832    13
47440    10
83287     9
Name: customer_id, dtype: int64


tableit(top_3_customers, index_label='Customer ID', value_label='Order Count')

+---------------+---------------+
|   Customer ID |   Order Count |
+===============+===============+
|         52832 |            13 |
+---------------+---------------+
|         47440 |            10 |
+---------------+---------------+
|         83287 |             9 |
+---------------+---------------+


# Explore more (Customer Repeat)
order_counts.describe()

count    1200.000000
mean        1.581667
std         1.090560
min         1.000000
25%         1.000000
50%         1.000000
75%         2.000000
max        13.000000
Name: customer_id, dtype: float64


order_counts[order_counts > 2].count()

149


149 / 1200 * 100

12.416666666666666


x = 'cuisine_type'
y = 'day_of_the_week'


df[x].nunique(), df[y].nunique()

(14, 2)


# Plot
heatmap_data = pd.crosstab(df['cuisine_type'], df['day_of_the_week'])

sns.heatmap(heatmap_data, annot=True, fmt="d", cmap="Blues", cbar=True, linewidths=0.5)

# aesthetics
plt.title("Cuisine Type vs Day of the Week")
plt.xlabel("Day of the Week")
plt.ylabel("Cuisine Type")
plt.xticks(rotation=45)
plt.show()


# Plot 2 (Stacked Bar Chart)

# Calculate the count of orders for each cuisine_type and day_of_the_week
order_counts = pd.crosstab(df['cuisine_type'], df['day_of_the_week'])

# Normalize to get percentages
order_percentages = order_counts.div(order_counts.sum(axis=1), axis=0) * 100

# Plot the stacked bar plot
order_percentages.plot(kind='bar', stacked=True)

# Customize the plot
plt.title('Percentage of Orders by Cuisine Type and Day of the Week')
plt.xlabel('Cuisine Type')
plt.ylabel('Percentage of Orders')
plt.xticks(rotation=45, ha='right')
plt.legend(title='Day of the Week', bbox_to_anchor=(1.05, 1), loc='upper left')

plt.show()


# Plot 3

# Calculate the count of orders for each cuisine_type and day_of_the_week
order_counts = pd.crosstab(df['cuisine_type'], df['day_of_the_week'])

# Plot the grouped bar plot
order_counts.plot(kind='bar', stacked=False)

# Customize the plot
plt.title('#Orders by Cuisine Type and Day of the Week')
plt.xlabel('Cuisine Type')
plt.ylabel('Orders Count')
plt.xticks(rotation=45, ha='right')
plt.legend(title='Day of the Week', bbox_to_anchor=(1.05, 1), loc='upper left')

plt.tight_layout()
plt.show()


# Plot 1
sns.violinplot(data=df, x='rating', y='cost_of_the_order')
plt.title('Distribution of Order Costs by Customer Ratings')
plt.xlabel('Rating')
plt.ylabel('Cost of the Order')
plt.show()


avg_cost_by_rating = original_df.groupby('rating')['cost_of_the_order'].mean().reset_index()
avg_cost_by_rating


# Plot 2 (Count)

# create a bar plot to show the average cost for each rating
ax = sns.barplot(data=avg_cost_by_rating, x='rating', y='cost_of_the_order')

# add count above each bar
ax.bar_label(ax.containers[0])

# Add title and labels
plt.title('Average Cost of the Order by Rating')
plt.xlabel('Rating')
plt.ylabel('Average Cost of the Order')

# Show the plot
plt.show()


x = 'day_of_the_week'
y = 'delivery_time'
df[x].nunique(), df[y].nunique()

(2, 19)


# Plot 1

# box plot between day of the week and delivery time
sns.boxplot(data=df, x=x, y=y)

# add title and labels
plt.title('Delivery Time Comparision: Weekdays vs Weekends')
plt.xlabel('Day of the Week')
plt.ylabel('Delivery Time (mins)')

# show the plot
plt.show()


# calculate median time for each day of the week
median_delivery_time = df.groupby('day_of_the_week')['delivery_time'].median().reset_index()
median_delivery_time


# Plot 2

# Strip plot for day_of_the_week vs delivery_time
sns.stripplot(x='day_of_the_week', y='delivery_time', data=df, jitter=True)

# Adding labels and title
plt.title('Delivery Time Comparision: Weekdays vs Weekends')
plt.xlabel('Day of the Week')
plt.ylabel('Delivery Time')

# Show plot
plt.show()


x = 'rating'
y = 'delivery_time'
df[x].nunique(), df[y].nunique()

(3, 19)


# Plot 1

# Drop rows with NaN values in the 'rating' column (for this pair analysis)
df_clean = df.dropna(subset=['rating'])

sns.swarmplot(data=df_clean, x='rating', y='delivery_time', alpha=0.7)

plt.title('Customer Rating vs Delivery Time')
plt.xlabel('Rating')
plt.ylabel('Delivery Time (minutes)')
plt.show()


# plot 2
sns.violinplot(data=df, x='rating', y='delivery_time')
plt.title('Customer Rating vs Delivery Time')
plt.xlabel('Rating')
plt.ylabel('Delivery Time (minutes)')
plt.show()


sns.boxplot(data=df, x='rating', y='delivery_time')
plt.title('Customer Rating vs Delivery Time')
plt.xlabel('Rating')
plt.ylabel('Delivery Time (minutes)')
plt.show()


# stats
avg_delivery_time_by_rating = df.groupby('rating')['delivery_time'].mean().reset_index()
avg_delivery_time_by_rating


sns.boxplot(data=df, x='cuisine_type', y='cost_of_the_order')
plt.title('Cost of the Order vs Cuisine Type')
plt.xlabel('Cuisine Type')
plt.ylabel('Cost of the Order')
plt.xticks(rotation=45)
plt.show()


# create bar plot
sns.barplot(data=df, x='cuisine_type', y='cost_of_the_order')

# title and labels
plt.title('Average Cost of the Order by Cuisine Type')
plt.xlabel('Cuisine Type')
plt.ylabel('Average Cost')

# Rotate x-axis labels
plt.xticks(rotation=45)

# show the plot
plt.show()


# Stats
avg_cost_by_cuisine = df.groupby('cuisine_type')['cost_of_the_order'].mean().reset_index()
avg_cost_by_cuisine


x = 'restaurant_name'
y = 'cuisine_type'

df[x].nunique(), df[y].nunique()

(178, 14)


# PREP (Data Preparation)

# Filter for top 10 restaurants by order count
famous_restaurants = df['restaurant_name'].value_counts().head(10).index
filtered_df = df[df['restaurant_name'].isin(famous_restaurants)]

# hence we will deal with filtered_df
filtered_df.head()


# Plot 1

sns.countplot(data=filtered_df, x='restaurant_name', hue='cuisine_type')
plt.title('Cuisine Types for Top 10 Restaurants')
plt.xlabel('Restaurant Name')
plt.ylabel('Count')
plt.xticks(rotation=45)
plt.legend(title='Cuisine Type', bbox_to_anchor=(1.05, 1), loc='upper left')
plt.show()


# Stats

# get order count for restaurant by cuisine type
restaurant_cuisine_count = filtered_df.groupby(['restaurant_name', 'cuisine_type']).size().unstack().fillna(0)
restaurant_cuisine_count


# Plot 2 (Pivot Table)

# Create a pivot table
pivot_table = df.pivot_table(index='restaurant_name', columns='cuisine_type', aggfunc='size', fill_value=0)

# Filter for top 10 restaurants
k = 10
top_restaurant_pivot = pivot_table.loc[pivot_table.sum(axis=1).nlargest(k).index]

sns.heatmap(top_restaurant_pivot, annot=True, fmt='d', cmap='Blues', cbar=True)
plt.title(f'Cuisine Type Distribution Across Top {k} Restaurants')
plt.xlabel('Cuisine Type')
plt.ylabel('Restaurant Name')
plt.show()


x = 'restaurant_name'
y = 'food_preparation_time'
df[x].nunique(), df[y].nunique()

(178, 16)


# PREP (Data Preparation)

# Filter for top 10 restaurants by order count
famous_restaurants = df['restaurant_name'].value_counts().head(10).index
filtered_df = df[df['restaurant_name'].isin(famous_restaurants)]


print("Top 10 Restaurants by Order Count :")
print(famous_restaurants)

Top 10 Restaurants by Order Count :
Index(['Shake Shack', 'The Meatball Shop', 'Blue Ribbon Sushi',
       'Blue Ribbon Fried Chicken', 'Parm', 'RedFarm Broadway',
       'RedFarm Hudson', 'TAO', 'Han Dynasty',
       'Blue Ribbon Sushi Bar & Grill'],
      dtype='object')


# Plot
sns.boxplot(data=filtered_df, x='restaurant_name', y='food_preparation_time')
plt.title('Food Preparation Time Distribution for Top 10 Restaurants')
plt.xlabel('Restaurant Name')
plt.ylabel('Food Preparation Time (minutes)')
plt.xticks(rotation=45)
plt.show()


# Plot 2 (Horizontal Bar Plot)

restaurant_avg_prep_time = filtered_df.groupby('restaurant_name')['food_preparation_time'].mean().sort_values()
# plot (horizontal bars)
restaurant_avg_prep_time.plot(kind='barh')
# aesthetics
plt.title('Average Food Preparation Time for Top 10 Restaurants')
plt.xlabel('Average Preparation Time (minutes)')
plt.ylabel('Restaurant Name')
# note: need to provide grid property here manually
plt.grid(axis='y', linestyle='--', alpha=0.7)
plt.show()


# Plot 3
sns.violinplot(data=filtered_df, x='restaurant_name', y='food_preparation_time', inner="box")
plt.title('Density of Food Preparation Time for Top 10 Restaurants')
plt.xlabel('Restaurant Name')
plt.ylabel('Food Preparation Time (minutes)')
plt.xticks(rotation=45)
plt.show()


# Plot 4

sns.pointplot(
    data=filtered_df,
    x="food_preparation_time",
    y="restaurant_name",
    palette="Set2",
    join=False,
    markers="o",
    linestyles="--",
)
plt.title("Average Food Preparation Time per Restaurant")
plt.xlabel("Food Preparation Time (minutes)")
plt.ylabel("Restaurant Name")
plt.grid(axis="x", linestyle="--", alpha=0.7)
plt.show()


# get stats for food preparation time for top 10 restaurants
restaurant_food_preparation_time = filtered_df.groupby('restaurant_name')['food_preparation_time'].describe()
restaurant_food_preparation_time


# Just to see prep time in sorted order refering this
restaurant_avg_prep_time

restaurant_name
Blue Ribbon Sushi Bar & Grill    26.295455
TAO                              26.775510
RedFarm Hudson                   27.163636
The Meatball Shop                27.181818
Blue Ribbon Fried Chicken        27.197917
Parm                             27.308824
Han Dynasty                      27.413043
RedFarm Broadway                 27.593220
Blue Ribbon Sushi                27.924370
Shake Shack                      27.945205
Name: food_preparation_time, dtype: float64


x = 'cuisine_type'
y = 'food_preparation_time'
df[x].nunique(), df[y].nunique()

(14, 16)


# Plot 1
sns.violinplot(data=df, x='cuisine_type', y='food_preparation_time', inner="box")
plt.title('Density & Distibution of Food Preparation Time for Cuisines')
plt.xlabel('Cuisines')
plt.ylabel('Food Preparation Time (minutes)')
plt.xticks(rotation=45)
plt.show()


# Plot 2

# Plot the strip plot
sns.stripplot(
    data=df,
    x='food_preparation_time',
    y='cuisine_type',
    jitter=True,
    alpha=0.7,
    palette='Set1',
)
plt.title("Food Preparation Time For Cusines")
plt.xlabel("Food Preparation Time (minutes)")
plt.ylabel("Cusines")
plt.grid(axis="x", linestyle="--", alpha=0.7)
plt.show()


# Get Descriptive Stats about food preparation time for each cuisine type
cuisine_prep_time_stats = df.groupby('cuisine_type')['food_preparation_time'].describe()
cuisine_prep_time_stats


restaurant_prep_time = df.groupby('cuisine_type')['food_preparation_time'].median().sort_values()
restaurant_prep_time

cuisine_type
Korean            25.0
Vietnamese        25.0
French            25.5
Mexican           26.0
Southern          26.0
American          27.0
Chinese           27.0
Indian            27.0
Mediterranean     27.0
Middle Eastern    27.0
Japanese          27.5
Spanish           27.5
Italian           28.0
Thai              28.0
Name: food_preparation_time, dtype: float64


x = 'cost_of_the_order'
y = 'food_preparation_time'


# Get correlation between 2 variables
df[x].corr(df[y])

0.04152747282774475


df[[x, y]].corr()


sns.lmplot(data=df,
           x='food_preparation_time',
           y='cost_of_the_order',
           height=6, aspect=2.5,
           scatter_kws={'alpha': 0.6},  # Transparency for scatter points
           line_kws={'linewidth': 1.5, 'color': 'red'})  # Thicker regression lines
plt.title('Cost of Order vs Food Preparation Time', y=1.03)
plt.xlabel('Food Preparation Time (minutes)')
plt.ylabel('Cost of Order')
plt.grid(alpha=0.3)
plt.show()


sns.kdeplot(
    data=df,
    x="food_preparation_time",
    y="cost_of_the_order",
)
plt.title("Cost of Order vs Food Preparation Time")
plt.xlabel("Food Preparation Time (minutes)")
plt.ylabel("Cost of Order")
plt.grid(alpha=0.3)
plt.show()


x = 'cuisine_type'
y = 'cost_of_the_order'
z = 'day_of_the_week'


cost_of_cuisine_by_day = df.groupby([x, z])[y].mean()
cost_of_cuisine_by_day

cuisine_type    day_of_the_week
American        Weekday            15.308343
                Weekend            16.731735
Chinese         Weekday            17.147692
                Weekend            16.036442
French          Weekday            20.866000
                Weekend            19.381538
Indian          Weekday            17.162500
                Weekend            16.800816
Italian         Weekday            16.890110
                Weekend            16.211449
Japanese        Weekday            16.368074
                Weekend            16.278925
Korean          Weekday            12.180000
                Weekend            14.332727
Mediterranean   Weekday            14.040000
                Weekend            16.102500
Mexican         Weekday            16.555833
                Weekend            17.103962
Middle Eastern  Weekday            19.832941
                Weekend            18.282812
Southern        Weekday            19.226667
                Weekend            19.340909
Spanish         Weekday            12.130000
                Weekend            19.618182
Thai            Weekday            15.462500
                Weekend            20.206667
Vietnamese      Weekday            11.916667
                Weekend            13.607500
Name: cost_of_the_order, dtype: float64


# convert to table form by unstack
# NOTE: second level (ie day_of_the_week) will become column
cost_of_cuisine_by_day_tbl = cost_of_cuisine_by_day.unstack()
cost_of_cuisine_by_day_tbl


# Plot 1
sns.barplot(data=df, x=x, y=y, hue=z)
plt.title('Average Cost of Order by Cuisine Type and Day of the Week')
plt.xlabel('Cuisine Type')
plt.ylabel('Average Cost of Order')
plt.xticks(rotation=45)
plt.legend(title='Day of the Week', loc='upper left')
plt.show()


# Plot 2

sns.boxplot(data=df, x=x, y=y, hue=z)
plt.title('Distribution Summary of Order Cost by Cuisine Type and Day of the Week')
plt.xlabel('Cuisine Type')
plt.ylabel('Average Cost of Order')
plt.xticks(rotation=45)
plt.legend(title='Day of the Week', loc='upper left')
plt.show()


spanish_weekday_orders = df[(df['cuisine_type'] == 'Spanish') & (df['day_of_the_week'] == 'Weekday')]
spanish_weekday_orders


korean_weekday_orders = df[(df['cuisine_type'] == 'Korean') & (df['day_of_the_week'] == 'Weekday')]
korean_weekday_orders


x = 'cost_of_the_order'
y = 'preparation_time'
z = 'rating'


# Plot
g = sns.jointplot(
    data=df,
    x="cost_of_the_order",
    y="food_preparation_time",
    kind="reg",  # Regression plot
    height=8,  # Figure size
    space=0.5,  # Space between main plot and marginal plots
    marginal_kws={"bins": 20, "fill": True},  # Styling marginal histograms
    color="teal",
)
plt.suptitle(
    "Relationship Between Cost of Order and Food Preparation Time", y=1.02, fontsize=14
)
g.figure.set_figwidth(15)
g.figure.set_figheight(6)
plt.show()


g = sns.jointplot(
    data=df,
    x="cost_of_the_order",
    y="food_preparation_time",
    kind="hex",  # Scatter plot
    height=7,  # Figure size
    space=0.5,  # Space between main plot and marginal plots
)
plt.suptitle(
    "Relationship Between Cost of Order and Food Preparation Time", y=1.02, fontsize=14
)
g.figure.set_figwidth(15)
g.figure.set_figheight(7)
plt.show()


# Plot
g = sns.jointplot(
    data=df,
    x="cost_of_the_order",
    y="food_preparation_time",
    kind="scatter",  # Scatter plot
    height=6,  # Figure size
    hue="rating",
    space=0.5,  # Space between main plot and marginal plots
    color="teal",
)
plt.suptitle(
    "Relationship Between Cost of Order and Food Preparation Time", y=1.02, fontsize=14
)
g.figure.set_figwidth(15)
g.figure.set_figheight(6)
plt.show()


# Plot
sns.swarmplot(
    data=df,
    x='rating',
    y='food_preparation_time',
    hue='rating',
    dodge=True,
)
plt.title('Food Preparation Time vs Rating')
plt.xlabel('Rating')
plt.ylabel('Food Preparation Time')
plt.legend(title='Rating')
plt.show()


# Plot
g = sns.FacetGrid(df, col='rating', col_wrap=3, height=4, aspect=1.2, sharex=False, sharey=False)
g.map(sns.scatterplot, 'cost_of_the_order', 'food_preparation_time', alpha=0.7, color='teal')
g.set_titles("Rating: {col_name}")
g.set_axis_labels("Cost of the Order", "Food Preparation Time")
g.figure.suptitle('Cost vs Food Preparation Time by Rating', y=1.02, fontsize=14)
plt.show()


# Plot
fig = plt.figure(figsize=(15, 6))
ax = fig.add_subplot(111, projection='3d')

# Scatter plot
sc = ax.scatter(
    df['cost_of_the_order'],
    df['food_preparation_time'],
    df['rating'],
    c=df['rating'], cmap='viridis', alpha=0.8
)

# Axis labels
ax.set_xlabel('Cost of the Order')
ax.set_ylabel('Food Preparation Time')
ax.set_zlabel('Rating')

# Colorbar
cbar = plt.colorbar(sc, ax=ax, pad=0.1)
cbar.set_label('Rating')

plt.title('3D Scatter: Cost, Preparation Time, and Rating')
plt.show()


# Plot

# Calculate correlation matrix
corr_matrix = df[['cost_of_the_order', 'food_preparation_time', 'rating']].corr()

# Plot heatmap
plt.figure(figsize=(8, 6))
sns.heatmap(corr_matrix, annot=True, cmap='Blues', fmt='.2f', linewidths=0.5)
plt.title('Correlation Heatmap of Cost, Food Preparation Time, and Rating')
plt.show()


# Left Blank Intentionally !! (For Gap)


# Snity check

# Seems good as rating column is of numeric type (as converted)
df.head()


# ? Assumption - at this point column 'rating' has no missing values & it's type is numeric

# 2. Group by restaurant name and calculate the count of ratings and the average rating
restaurant_stats = df.groupby('restaurant_name')['rating'].agg(['count', 'mean'])

# 3. Filter restaurants based on the criteria: count > 50 and mean > 4
eligible_restaurants = restaurant_stats[(restaurant_stats['count'] > 50) & (restaurant_stats['mean'] > 4)]

# 4. Display the eligible restaurants
tableit_df(eligible_restaurants, show_index=True)

+---------------------------+-------+--------------------+
|      restaurant_name      | count |        mean        |
+---------------------------+-------+--------------------+
| Blue Ribbon Fried Chicken | 64.0  |      4.328125      |
|     Blue Ribbon Sushi     | 73.0  | 4.219178082191781  |
|        Shake Shack        | 133.0 | 4.2781954887218046 |
|     The Meatball Shop     | 84.0  | 4.511904761904762  |
+---------------------------+-------+--------------------+


# ! Printing raw as well (as if above tabular doesnt work i.e missing module case or display incosistency)
eligible_restaurants


print('Eligible Restaurants for Promotional Offer:')
eligible_restaurants.index.to_list()

Eligible Restaurants for Promotional Offer:

['Blue Ribbon Fried Chicken',
 'Blue Ribbon Sushi',
 'Shake Shack',
 'The Meatball Shop']


def calculate_revenue(row):
    ''' Calculate revenue based on cost of order'''
    # ? NOTE : the unit of currency is dollar
    match row['cost_of_the_order']:
        case cost if cost > 20: # more than 20 dollar
            return cost * 0.25
        case cost if cost > 5:  # more than 5 dollar
            return cost * 0.15
        case _:                 # less than or equal to 5 dollar
            return 0

# Apply the function to each row and calculate the total revenue
orders_revenue = df.apply(calculate_revenue, axis=1)

# Calculate total net revenue generated
total_revenue = orders_revenue.sum()

# Display the total revenue
print(f"Total Net Revenue Generated by the Company across all orders is: ${total_revenue:.2f}")

Total Net Revenue Generated by the Company across all orders is: $6166.30


# Calculate total time = (food preparation time + delivery time)
order_total_delivery_time = df['food_preparation_time'] + df['delivery_time']

# Find percentage of orders taking more than 60 minutes
percentage_orders_above_60min = (order_total_delivery_time > 60).mean() * 100

# Result
print(f"Percentage of orders taking more than 60 minutes from the time the order is placed is: {format_pct(percentage_orders_above_60min)}")

Percentage of orders taking more than 60 minutes from the time the order is placed is: 10.54%


mean_delivery_time_by_day = df.groupby('day_of_the_week')['delivery_time'].mean()
tableit(mean_delivery_time_by_day)

+-----------------+---------+
| delivery_time   |   value |
+=================+=========+
| Weekday         |   28.34 |
+-----------------+---------+
| Weekend         |   22.47 |
+-----------------+---------+


# ! Printing raw as well (in case above tabular doesnt work i.e missing module case or display incosistency)
mean_delivery_time_by_day

day_of_the_week
Weekday    28.340037
Weekend    22.470022
Name: delivery_time, dtype: float64


# Just an analysis for curiosity of Indian Dishes
indian_orders = (df['cuisine_type'] == 'Indian').sum()
indian_orders_pct = indian_orders / total_orders * 100
format_pct(indian_orders_pct)

'3.85%'

	rating	cost_of_the_order
0	3	16.223351
1	4	16.710337
2	5	16.965697
3	Not given	16.085340

	order_id	customer_id	restaurant_name	cuisine_type	cost_of_the_order	day_of_the_week	rating	food_preparation_time	delivery_time
0	1477147	337525	Hangawi	Korean	30.75	Weekend	Not given	25	20
1	1477685	358141	Blue Ribbon Sushi Izakaya	Japanese	12.08	Weekend	Not given	25	23
2	1477070	66393	Cafe Habana	Mexican	12.23	Weekday	5	23	28
3	1477334	106968	Blue Ribbon Fried Chicken	American	29.20	Weekend	3	25	15
4	1478249	76942	Dirty Bird to Go	American	11.59	Weekday	4	25	24

	count	unique	top	freq	mean	std	min	25%	50%	75%	max
order_id	1898.0	NaN	NaN	NaN	1477495.5	548.049724	1476547.0	1477021.25	1477495.5	1477969.75	1478444.0
customer_id	1898.0	NaN	NaN	NaN	171168.478398	113698.139743	1311.0	77787.75	128600.0	270525.0	405334.0
restaurant_name	1898	178	Shake Shack	219	NaN	NaN	NaN	NaN	NaN	NaN	NaN
cuisine_type	1898	14	American	584	NaN	NaN	NaN	NaN	NaN	NaN	NaN
cost_of_the_order	1898.0	NaN	NaN	NaN	16.498851	7.483812	4.47	12.08	14.14	22.2975	35.41
day_of_the_week	1898	2	Weekend	1351	NaN	NaN	NaN	NaN	NaN	NaN	NaN
rating	1898	4	Not given	736	NaN	NaN	NaN	NaN	NaN	NaN	NaN
food_preparation_time	1898.0	NaN	NaN	NaN	27.37197	4.632481	20.0	23.0	27.0	31.0	35.0
delivery_time	1898.0	NaN	NaN	NaN	24.161749	4.972637	15.0	20.0	25.0	28.0	33.0

	cuisine_type	cost_of_the_order
0	American	16.319829
1	Chinese	16.305209
2	French	19.793889
3	Indian	16.919726
4	Italian	16.418691
5	Japanese	16.304532
6	Korean	14.001538
7	Mediterranean	15.474783
8	Mexican	16.933117
9	Middle Eastern	18.820612
10	Southern	19.300588
11	Spanish	18.994167
12	Thai	19.207895
13	Vietnamese	12.882857

cuisine_type	American	Chinese	Italian	Japanese
restaurant_name
Blue Ribbon Fried Chicken	96.0	0.0	0.0	0.0
Blue Ribbon Sushi	0.0	0.0	0.0	119.0
Blue Ribbon Sushi Bar & Grill	0.0	0.0	0.0	44.0
Han Dynasty	0.0	46.0	0.0	0.0
Parm	0.0	0.0	68.0	0.0
RedFarm Broadway	0.0	59.0	0.0	0.0
RedFarm Hudson	0.0	55.0	0.0	0.0
Shake Shack	219.0	0.0	0.0	0.0
TAO	0.0	0.0	0.0	49.0
The Meatball Shop	20.0	0.0	112.0	0.0

	count	mean	std	min	25%	50%	75%	max
cuisine_type
American	584.0	27.440068	4.658474	20.0	23.00	27.0	31.0	35.0
Chinese	215.0	27.511628	4.758525	20.0	23.50	27.0	32.0	35.0
French	18.0	26.888889	5.039712	21.0	22.50	25.5	31.0	35.0
Indian	73.0	27.109589	4.620491	20.0	23.00	27.0	31.0	35.0
Italian	298.0	27.483221	4.519474	20.0	23.00	28.0	31.0	35.0
Japanese	470.0	27.510638	4.604496	20.0	24.00	27.5	32.0	35.0
Korean	13.0	25.461538	3.971049	20.0	23.00	25.0	26.0	33.0
Mediterranean	46.0	27.000000	4.908043	20.0	23.00	27.0	31.0	35.0
Mexican	77.0	26.727273	4.604450	20.0	23.00	26.0	31.0	35.0
Middle Eastern	49.0	26.673469	4.012417	20.0	24.00	27.0	30.0	34.0
Southern	17.0	27.588235	5.523346	20.0	24.00	26.0	33.0	35.0
Spanish	12.0	26.916667	4.501683	20.0	23.75	27.5	28.5	35.0
Thai	19.0	27.315789	5.498006	21.0	22.00	28.0	32.5	35.0
Vietnamese	7.0	25.714286	5.154748	20.0	21.50	25.0	29.5	33.0

	cost_of_the_order	food_preparation_time
cost_of_the_order	1.000000	0.041527
food_preparation_time	0.041527	1.000000

day_of_the_week	Weekday	Weekend
cuisine_type
American	15.308343	16.731735
Chinese	17.147692	16.036442
French	20.866000	19.381538
Indian	17.162500	16.800816
Italian	16.890110	16.211449
Japanese	16.368074	16.278925
Korean	12.180000	14.332727
Mediterranean	14.040000	16.102500
Mexican	16.555833	17.103962
Middle Eastern	19.832941	18.282812
Southern	19.226667	19.340909
Spanish	12.130000	19.618182
Thai	15.462500	20.206667
Vietnamese	11.916667	13.607500

	order_id	customer_id	restaurant_name	cuisine_type	cost_of_the_order	day_of_the_week	rating	food_preparation_time	delivery_time
1449	1477461	241719	Kori Restaurant and Bar	Korean	12.18	Weekday	4.0	26	26
1859	1476790	141732	Cho Dang Gol	Korean	12.18	Weekday	5.0	20	26

	count	mean
restaurant_name
Blue Ribbon Fried Chicken	64	4.328125
Blue Ribbon Sushi	73	4.219178
Shake Shack	133	4.278195
The Meatball Shop	84	4.511905

Introduction to Python Project : FoodHub Data Analysis¶

Problem Statement¶

Data Dictionary¶

Let us start by importing the required libraries¶

🛠️ Python Utils¶

Understanding the structure of the data¶

Question 1: How many rows and columns are present in the data? [0.5 mark]¶

Question 2: What are the datatypes of the different columns in the dataset? (The info() function can be used) [0.5 mark]¶

Question 3: Are there any missing values in the data? If yes, treat them using an appropriate method. [1 mark]¶

Question 4: Check the statistical summary of the data. What is the minimum, average, and maximum time it takes for food to be prepared once an order is placed? [2 marks]¶

Question 5: How many orders are not rated? [1 mark]¶

Data Cleaning / Data PreProcessing¶

Exploratory Data Analysis (EDA)¶

Univariate Analysis¶

🛠️ Python Utils¶

Question 6: Explore all the variables and provide observations on their distributions. (Generally, histograms, boxplots, countplots, etc. are used for univariate exploration.) [9 marks]¶

Attribute: restaurant_name¶

Attribute: cuisine_type¶

Attribute: cost_of_the_order¶

Attribute: day_of_the_week¶

Attribute: rating¶

Attribute: food_preparation_time¶

Attribute: delivery_time¶

Question 7: Which are the top 5 restaurants in terms of the number of orders received? [1 mark]¶

Question 8: Which is the most popular cuisine on weekends? [1 mark]¶

Question 9: What percentage of the orders cost more than 20 dollars? [2 marks]¶

Question 10: What is the mean order delivery time? [1 mark]¶

Observations:¶

Question 11: The company has decided to give 20% discount vouchers to the top 3 most frequent customers. Find the IDs of these customers and the number of orders they placed. [1 mark]¶

Multivariate Analysis¶

Question 12: Perform a multivariate analysis to explore relationships between the important variables in the dataset. (It is a good idea to explore relations between numerical variables as well as relations between numerical and categorical variables) [10 marks]¶

1. Cuisine Type and Day of the Week¶

2. Customer Ratings & Cost of the Orders¶

3. Day of Week & Delivery Time¶

4. Delivery Time & Customer Ratings¶

5. Cost of Order & Cuisine Types¶

6. Restaurant Name & Cusine Type¶

7. Restaurant Name & Food Preparation Time¶

8. Cuisine Type & Food Preparation Time¶

9. Cost of Order & Food Preparation Time¶

10. Cusine Type, Cost of Order, Day of Week¶

11. Ratings, Cost of Order & Food Preparation Time¶

Question 14: The company charges the restaurant 25% on the orders having cost greater than 20 dollars and 15% on the orders having cost greater than 5 dollars. Find the net revenue generated by the company across all orders. [3 marks]¶

Question 15: The company wants to analyze the total time required to deliver the food. What percentage of orders take more than 60 minutes to get delivered from the time the order is placed? (The food has to be prepared and then delivered.) [2 marks]¶

Question 16: The company wants to analyze the delivery time of the orders on weekdays and weekends. How does the mean delivery time vary during weekdays and weekends? [2 marks]¶

Conclusion and Recommendations¶

Question 17: What are your conclusions from the analysis? What recommendations would you like to share to help improve the business? (You can use cuisine type and feedback ratings to drive your business recommendations.) [6 marks]¶

Conclusions:¶

Recommendations:¶